home *** CD-ROM | disk | FTP | other *** search
/ PC World Interactive 7 / PC World Interactive 7.iso / program / ctutor.exe / TEXT / CHAP09.TXT < prev    next >
Text File  |  1994-05-15  |  31KB  |  638 lines

  1.  
  2.  
  3.  
  4.                                                         Chapter 9
  5.                                             STANDARD INPUT/OUTPUT
  6.  
  7. THE STDIO.H HEADER FILE
  8. -----------------------------------------------------------------
  9. Examine the file SIMPLEIO.C for our first look   ================
  10. at a file with standard I/O.  Standard I/O          SIMPLEIO.C
  11. refers to the most usual places where data is    ================
  12. either read from, the keyboard, or written to, 
  13. the video monitor.  Since they are used so much, they are used as 
  14. the default I/O devices and do not need to be named in the 
  15. Input/Output instructions.  This will make more sense when we 
  16. actually start to use them so let's look at the file in front 
  17. of you.
  18.  
  19. The first thing you should take notice of is the second line of 
  20. the example file, the line with #include "stdio.h".  This is very 
  21. much like the #define we have already studied, except that 
  22. instead of a simple substitution, an entire file is read in at 
  23. this point.  The system will find the file named STDIO.H and read 
  24. its entire contents in, replacing this statement.  Obviously 
  25. then, the file named STDIO.H must contain valid C source 
  26. statements that can be compiled as part of a program.  You will 
  27. recall that we stated earlier that the preprocessor does textual 
  28. substitution.  This particular file is composed of several 
  29. standard #defines to define some of the standard I/O operations.  
  30. The file is called a header file and you will find several 
  31. different header files on the source disks that came with your C 
  32. compiler.  Each of the header files has a specific purpose and 
  33. any or all of them can be included in any program.  Most header 
  34. files contain definitions of a few types, function prototypes for 
  35. the functions in its group, and some macros.
  36.  
  37. Your C compiler uses the double quote marks to indicate that the 
  38. search for the include file will begin in the current directory, 
  39. and if it not found there, the search will continue in the 
  40. include directory as set up in the environment for your compiler.  
  41. It also uses the "less than" and "greater than" signs to indicate 
  42. that the file search should begin in the directory specified in 
  43. the environment.  Most of the programs in this tutorial have the 
  44. double quotes in the include statements.  The next program uses 
  45. the "<" and ">" to illustrate the usage.  Note that this will 
  46. result is a slightly faster (but probably unnoticeable) 
  47. compilation because the system will not bother to search the 
  48. current directory first.  If you know the include file is not in 
  49. the current directory, it is best to use the "<" and ">" with the 
  50. filename.
  51.  
  52. As many includes can be used as necessary, and it is perfectly 
  53. all right for one header file to include one or more additional 
  54. header files.  It is very common to include four or five header 
  55. files in a program.
  56.  
  57.                                                          Page 9-1
  58.  
  59.                                 Chapter 9 - Standard Input/Output
  60.  
  61. INPUT/OUTPUT OPERATIONS IN C
  62. -----------------------------------------------------------------
  63. Actually the C programming language has no input or output 
  64. operations defined as part of the language, they must be user 
  65. defined.  Since everybody does not want to reinvent his own input 
  66. and output operations, the compiler writers have done a lot of 
  67. this for us and supplied us with several input functions and 
  68. several output functions to aid in our program development.  The 
  69. functions have become a standard, and you will find the same 
  70. functions available in nearly every compiler.  In fact, the 
  71. industry standard of the C language definition has become the 
  72. book written by Kernigan and Ritchie, and they have included 
  73. these functions in their definition.  Occasionally, when reading 
  74. literature about C, you will find an author refer to K & R.  This 
  75. refers to the book, "The C Programming Language", written by 
  76. Kernigan and Ritchie.  You would be advised to purchase a copy 
  77. for reference.  As of this writing, a second edition of this book 
  78. is available and is definitely the preferred edition.
  79.  
  80. You should print out the file named STDIO.H and spend some time 
  81. studying it.  There will be a lot that you will not understand 
  82. about it, but parts of it will look familiar.  The name STDIO.H 
  83. is sort of cryptic for "standard input/output header", because 
  84. that is exactly what it is.  It defines the standard input and 
  85. output functions in the form of #defines, macros, and prototypes 
  86. for the functions.  Don't worry too much about the details of 
  87. this now.  You can always return to this topic later for more 
  88. study if it interests you, but you will really have no need to 
  89. completely understand the STDIO.H file.  You will have a 
  90. tremendous need to use it however, so these comments on its use 
  91. and purpose are necessary.
  92.  
  93.  
  94. OTHER INCLUDE FILES
  95. -----------------------------------------------------------------
  96. When you begin writing larger programs and splitting them up into 
  97. separately compiled portions, you will have occasion to use some 
  98. definitions common to each of the portions.  It would be to your 
  99. advantage to make a separate file containing the definitions and 
  100. use the #include to insert it into each of the files.  If you 
  101. want to change any of the common statements, you will only need 
  102. to change one file and you will be assured of having all of the 
  103. common statements agree.  This is getting a little ahead of 
  104. ourselves but you now have an idea how the #include directive 
  105. can be used.
  106.  
  107.  
  108. BACK TO THE FILE NAMED SIMPLEIO.C
  109. -----------------------------------------------------------------
  110. Let's continue our tour of the file in question.  The one 
  111. variable named c is defined and a message is printed out with the 
  112. familiar printf() function.  We then find ourselves in a 
  113. continuous loop as long as the value of c is not equal to 
  114.  
  115.                                                          Page 9-2
  116.  
  117.                                 Chapter 9 - Standard Input/Output
  118.  
  119. capital X.  If there is any question in your mind about the loop 
  120. control, you should review chapter 3 before continuing.  The two 
  121. new functions within the loop are of paramount interest in this 
  122. program since they are the new functions. These are functions to 
  123. read a character from the keyboard and display it on the monitor 
  124. one character at a time.
  125.  
  126. The function getchar() reads a single character from the standard 
  127. input device, the keyboard being assumed because that is the 
  128. standard input device, and assigns it to the variable named c.  
  129. The next function putchar(), uses the standard output device, the 
  130. video monitor, and outputs the character contained in the 
  131. variable named c.  The character is output at the current cursor 
  132. location and the cursor is advanced one space for the next 
  133. character.  The system is therefore taking care of a lot of the 
  134. overhead for us.  The loop continues reading and displaying 
  135. characters until we type a capital X which terminates the loop. 
  136.  
  137. Compile and run this program for a few surprises.  When you type 
  138. on the keyboard, you will notice that what you type is displayed 
  139. faithfully on the screen, and when you hit the return key, the 
  140. entire line is repeated.  We only told it to output each 
  141. character once but it seems to be saving the characters up and 
  142. redisplaying them.  A short explanation is in order.
  143.  
  144.  
  145. DOS IS HELPING US OUT
  146. -----------------------------------------------------------------
  147. We need to understand a little bit about how DOS works to 
  148. understand what is happening here.  When data is read from the 
  149. keyboard, under DOS control, the characters are stored in a 
  150. buffer until a carriage return is entered at which time the 
  151. entire string of characters is given to the program.  When the 
  152. characters are being typed, however, the characters are displayed 
  153. one at a time on the monitor.  This is called echo, and happens 
  154. in many of the applications you run. 
  155.  
  156. With the above paragraph in mind, it should be clear that when 
  157. you are typing a line of data into SIMPLEIO, the characters are 
  158. being echoed by DOS, and when you return the carriage by hitting 
  159. return or enter, the characters are given to the program.  As 
  160. each character is given to the program, it displays it on the 
  161. screen resulting in a repeat of the line typed in.  To better 
  162. illustrate this, type a line with a capital X somewhere in the 
  163. middle of the line.  You can type as many characters as you like 
  164. following the X and they will all display because the characters 
  165. are being read in under DOS, echoed to the monitor, and placed 
  166. in the DOS input buffer.  DOS doesn't think there is anything 
  167. special about a capital X.  When the string is given to the 
  168. program, however, the characters are accepted by the program one 
  169. at a time and sent to the monitor one at a time, until a capital 
  170. X is encountered.  After the capital X is displayed, the loop is 
  171. terminated, and the program is terminated.  The characters on the 
  172.  
  173.                                                          Page 9-3
  174.  
  175.                                 Chapter 9 - Standard Input/Output
  176.  
  177. input line following the capital X are not displayed because the 
  178. capital X signalled program termination.
  179.  
  180. Compile and run SIMPLEIO.C.  After running the program several 
  181. times and feeling confident that you understand the above 
  182. explanation, we will go on to another program.
  183.  
  184. Don't get discouraged by the above seemingly weird behavior of 
  185. the I/O system.  It is strange, but there are other ways to get 
  186. data into the computer.  You will actually find the above method 
  187. useful for many applications, and you will probably find some of 
  188. the following useful also.
  189.  
  190.  
  191. ANOTHER STRANGE I/O METHOD
  192. -----------------------------------------------------------------
  193. Load the file named SINGLEIO.C and display it    ================
  194. on your monitor for another method of character     SINGLEIO.C
  195. I/O.  Once again, we start with the standard     ================
  196. I/O header file using the "<" and ">" method of 
  197. defining it.  Then we define a variable named c, and we print a 
  198. welcoming message.  Like the last program, we are in a loop that 
  199. will continue to execute until we type a capital X, but the 
  200. action is a little different here.
  201.  
  202. The function named _getch() is a get character function.  It 
  203. differs from the function named getchar() in that it does not get 
  204. tied up in DOS.  It reads the character in without echo, and puts 
  205. it directly into the program where it is operated on immediately.  
  206. This function therefore reads a character, immediately displays 
  207. it on the screen, and continues the operation until a capital X 
  208. is typed.  Note that although _getch() is available with most 
  209. popular microcomputer C compilers, it is not included in the ANSI 
  210. standard and may not be available with all C compilers.  It's use 
  211. may therefore make a program nonportable.  If your compiler does 
  212. not support the _getch() function, use the getchar() function 
  213. instead.
  214.  
  215. When you compile and run this program, you will find that there 
  216. is no repeat of the lines when you hit a carriage return, and 
  217. when you hit the capital X, the program terminates immediately.  
  218. No carriage return is needed to get it to accept the line with 
  219. the X in it, so this program operates a little differently from 
  220. the last one.  However, we do have another problem here, since 
  221. there is no linefeed with the carriage return.
  222.  
  223.  
  224. NOW WE NEED A LINE FEED
  225. -----------------------------------------------------------------
  226. It is not apparent to you in most application    ================
  227. programs but when you hit the enter key, the        BETTERIN.C
  228. program supplies a linefeed to go with the       ================
  229. carriage return.  You need to return to the 
  230.  
  231.                                                          Page 9-4
  232.  
  233.                                 Chapter 9 - Standard Input/Output
  234.  
  235. left side of the monitor and you also need to drop down a line.  
  236. The linefeed is not automatic. We need to improve our program to 
  237. do this also.  If you will load and display the program named 
  238. BETTERIN.C, you will find a change to incorporate this feature.
  239.  
  240. In BETTERIN.C, we have two additional statements at the beginning 
  241. that will define the character codes for the linefeed (LF), and 
  242. the carriage return (CR).  If you look at any ASCII table you 
  243. will find that the codes 10 and 13 are exactly as defined here.  
  244. In the main program, after outputting the character in line 15, 
  245. we compare it to CR, and if it is equal to CR, we also output a 
  246. linefeed which is the LF.  We could have completely omitted the 
  247. two #define statements and used the statement 
  248. if (c == 13) putchar(10); but it would not be very descriptive of 
  249. what we are doing here.  The method used in this program 
  250. represents better programming practice.
  251.  
  252. You will notice that line 16 deviates from the usual style for an 
  253. if statement, but we have a choice.  We can format the code 
  254. anyway we desire to improve the readability.  It is strictly a 
  255. programmer's choice.
  256.  
  257. Compile and run BETTERIN.C to see if it does what we have said it 
  258. should do.  It should display exactly what you type in, including 
  259. a linefeed with each carriage return, and should stop immediately 
  260. when you type a capital X.  Once again, if your compiler does not 
  261. support _getch(), use the getchar() function.
  262.  
  263.  
  264. WHICH METHOD IS BEST?
  265. -----------------------------------------------------------------
  266. We have examined two methods of reading characters into a C 
  267. program, and are faced with a choice of which one we should use.  
  268. It really depends on the application because each method has 
  269. advantages and disadvantages. 
  270.  
  271. When using the first method, DOS is actually doing all of the 
  272. work for us by storing the characters in an input buffer and 
  273. signaling us when a full line has been entered.  We could write a 
  274. program that, for example, did a lot of calculations, then went 
  275. to get some input.  While we were doing the calculations, DOS 
  276. would be accumulating a line of characters for us, and they would 
  277. be there when we were ready for them.  However, we could not read 
  278. in single keystrokes because DOS would not report a buffer of 
  279. characters to us until it recognized a carriage return.
  280.  
  281. The second method, used in BETTERIN.C, allows us to get a single 
  282. character, and act on it immediately.  We do not have to wait 
  283. until DOS decides we can have a line of characters.  We cannot do 
  284. anything else while we are waiting for a character because we are 
  285. waiting for the input keystroke and tying up the entire machine.  
  286. This method is useful for highly interactive types of program 
  287.  
  288.  
  289.                                                          Page 9-5
  290.  
  291.                                 Chapter 9 - Standard Input/Output
  292.  
  293. interfaces.  It is up to you as the programmer to decide which is 
  294. best for your needs.
  295.  
  296. I should mention at this point that there is also an _ungetch() 
  297. function that works with the _getch() function.  If you _getch() 
  298. a character and find that you have gone one too far, you can 
  299. _ungetch() it back to the input device.  This simplifies some 
  300. programs because you don't know that you don't want the character 
  301. until you get it.  You can only _ungetch() one character back to 
  302. the input device, but that is sufficient to accomplish the task 
  303. this function was designed for.  It is difficult to demonstrate 
  304. this function in a simple program so its use will be up to you 
  305. to study when you need it.  Another function that may be 
  306. available with your compiler, but is not part of the ANSI 
  307. standard, is the _getche() function which is identical to the 
  308. _getch() function except that it echoes the character to the 
  309. monitor for you.
  310.  
  311. The discussion so far in this chapter should be a good indication 
  312. that, while the C programming language is very flexible, it does 
  313. put a lot of responsibility on you as the programmer to keep many 
  314. details in mind.
  315.  
  316.  
  317. NOW TO READ IN SOME INTEGERS
  318. -----------------------------------------------------------------
  319. Load and display the file named INTIN.C for an  =================
  320. example of reading some formatted data from          INTIN.C
  321. the keyboard.  The structure of this program    =================
  322. is very similar to the last three except that 
  323. we define an int type variable and loop until the variable 
  324. somehow acquires the value of 100.  Instead of reading in a 
  325. character at a time, as we have in the last three example 
  326. programs, we read in an entire integer value with one call using 
  327. the function named scanf().  This function is very similar to the 
  328. printf() that you have been using for quite some time by now 
  329. except that it is used for input instead of output.  Examine the 
  330. line with the scanf() and you will notice that it does not ask 
  331. for the variable valin directly, but gives the address of the 
  332. variable since it expects to have a value returned from the 
  333. function.  Recall that a function must have the address of a 
  334. variable in order to return a value to that variable in the 
  335. calling program.  Failing to supply a pointer to the parameter in 
  336. the scanf() function is the most common problem encountered in 
  337. using this function. 
  338.  
  339. The function scanf() scans the input line until it finds the 
  340. first data field.  It ignores leading blanks and in this case, 
  341. it reads integer characters until it finds a blank or an invalid 
  342. decimal character, at which time it stops reading and returns 
  343. the value. 
  344.  
  345.  
  346.  
  347.                                                          Page 9-6
  348.  
  349.                                 Chapter 9 - Standard Input/Output
  350.  
  351. Remembering our discussion above about the way the DOS input 
  352. buffer works, it should be clear that nothing is actually acted 
  353. on until a complete line is entered and it is terminated by a 
  354. carriage return.  At this time, the buffer is input, and our 
  355. program will search across the line reading all integer values 
  356. it can find until the line is completely scanned.  This is 
  357. because we are in a loop and we tell it to find a value, print 
  358. it, find another, print it, etc.  If you enter several values on 
  359. one line, it will read each one in succession and display the 
  360. values.  Entering the value of 100 will cause the program to 
  361. terminate, and entering the value 100 with other values 
  362. following, will cause termination before the following values 
  363. are considered. 
  364.  
  365.  
  366. IT MAKES WRONG ANSWERS SOMETIMES
  367. -----------------------------------------------------------------
  368. If you enter a number up to and including 32767, it will display 
  369. correctly, but if you enter a larger number, it will appear to 
  370. make an error unless your system uses a much larger range for an 
  371. int type variable.  For example, if you enter the value 32768, it 
  372. will display the value of -32768, entering the value 65536 will 
  373. display as a zero.  These are not errors but are caused by the 
  374. way an int variable is defined.  The most significant bit of the 
  375. 16 bit pattern available for the integer variable is the sign 
  376. bit, so there are only 15 bits left for the value.  The variable 
  377. can therefore only have the values from -32768 to 32767, any 
  378. other values are outside the range of integer variables.  This is 
  379. up to you to take care of in your programs.  It is another 
  380. example of the increased responsibility you must assume using C 
  381. rather than another high level language such as Pascal, Modula-2, 
  382. etc.
  383.  
  384. The above paragraph is true for most MS-DOS C compilers.  There 
  385. is a very small possibility that your compiler uses an integer 
  386. value stored in a field size other than 16 bits.  If that is the 
  387. case, the same principles will be true but with different limits 
  388. than those given above.
  389.  
  390. Compile and run this program, entering several numbers on a line 
  391. to see the results, and with varying numbers of blanks between 
  392. the numbers.  Try entering numbers that are too big to see what 
  393. happens, and finally enter some invalid characters to see what 
  394. the system does with nondecimal characters.
  395.  
  396.  
  397. CHARACTER STRING INPUT
  398. -----------------------------------------------------------------
  399. Load and display the file named STRINGIN.C for   ================
  400. an example of reading a string variable from        STRINGIN.C   
  401. the keyboard.  This program is identical to the  ================
  402. last one except that instead of an integer 
  403. variable, we have defined a string variable with an upper limit 
  404.  
  405.                                                          Page 9-7
  406.  
  407.                                 Chapter 9 - Standard Input/Output
  408.  
  409. of 24 characters (remember that a string variable must have a 
  410. null character at the end).  The variable in the scanf() does not 
  411. need an & because big is an array variable and by definition it 
  412. is already a pointer.  This program should require no additional 
  413. explanation.  Compile and run it to see if it works the way you 
  414. expect.
  415.  
  416. You probably got a surprise when you ran it because it separated 
  417. your sentence into separate words.  When used in the string mode 
  418. of input, scanf() reads characters into the string until it comes 
  419. to either the end of a line or a blank character.  Therefore, it 
  420. reads a word, finds the blank following it, and displays the 
  421. result.  Since we are in a loop, this program continues to read 
  422. words until it exhausts the DOS input buffer.  We have written 
  423. this program to stop whenever it finds a capital X in column 1, 
  424. but since the sentence is split up into individual words, it will 
  425. stop anytime a word begins with capital X.  Try entering a 5 word 
  426. sentence with a capital X as the first character in the third 
  427. word.  You should get the first three words displayed, and the 
  428. last two simply ignored when the program stops.
  429.  
  430. Try entering more than 24 characters to see what the program 
  431. does.  In an actual program, it is your responsibility to count 
  432. characters and stop when the input buffer is full.  You may be 
  433. getting the feeling that a lot of responsibility is placed on you 
  434. when writing in C.  Along with this responsibility you get a lot 
  435. of flexibility in the bargain also.
  436.  
  437.  
  438. INPUT/OUTPUT PROGRAMMING IN C
  439. -----------------------------------------------------------------
  440. C was not designed to be used as a language for lots of input and 
  441. output, but as a systems language where a lot of internal 
  442. operations are required.  You would do well to use another 
  443. language for I/O intensive programming, but C could be used if 
  444. you desire.  The keyboard input is very flexible, allowing you to 
  445. get at the data in a very low level way, but very little help is 
  446. given you.  It is therefore up to you to take care of all of the 
  447. bookkeeping chores associated with your required I/O operations.  
  448. This may seem like a real pain in the neck, but in any given 
  449. program, you only need to define your input routines once and 
  450. then use them as needed.  Don't let this worry you.  As you gain 
  451. experience with C, you will easily handle your I/O requirements.
  452.  
  453. One final point must be made about these I/O functions.  It is 
  454. perfectly permissible to intermix scanf() and getchar() functions 
  455. during read operations.  In the same manner, it is also fine to 
  456. intermix the output functions, printf() and putchar() in any way 
  457. you desire.
  458.  
  459.  
  460.  
  461.  
  462.  
  463.                                                          Page 9-8
  464.  
  465.                                 Chapter 9 - Standard Input/Output
  466.  
  467. IN MEMORY I/O
  468. -----------------------------------------------------------------
  469. The next operation may seem a little strange    =================
  470. at first, but you will probably see lots of          INMEM.C
  471. uses for it as you gain experience.  Load the   =================
  472. file named INMEM.C and display it for another 
  473. type of I/O, one that never accesses the outside world, but stays 
  474. in the computer.  In INMEM.C, we define a few variables, then 
  475. assign some values to the ones named numbers for illustrative 
  476. purposes and then use an sprintf() function.  The function acts 
  477. just like a normal printf() function except that instead of 
  478. printing the line of output to a device, it prints the line of 
  479. formatted output to a character string in memory.  In this case 
  480. the string goes to the string variable named line, because that 
  481. is the string name we inserted as the first argument in the 
  482. sprintf() function.  The spaces after the 2nd %d were put there to 
  483. illustrate that the next function will search properly across the 
  484. line.  We print the resulting string and find that the output is 
  485. identical to what it would have been by using a printf() instead 
  486. of the sprintf() in the first place.  You will see that when you 
  487. compile and run the program shortly.
  488.  
  489. Since the generated string is still in memory, we can now read it 
  490. with the function sscanf().  We tell the function in its first 
  491. argument that line is the string to use for its input, and the 
  492. remaining parts of the line are exactly what we would use if we 
  493. were going to use the scanf() function and read data from outside 
  494. the computer.  Note that it is essential that we use pointers to 
  495. the data because we want to return data from a function.  Just to 
  496. illustrate that there are many ways to declare a pointer several 
  497. methods are used, but all are ultimately pointers.  The first two 
  498. simply declare the address of the elements of the array, while 
  499. the last three use the fact that result, without the accompanying 
  500. subscript, is a pointer.  Just to keep it interesting, the values 
  501. are read back in reverse order.  Finally the values are displayed 
  502. on the monitor. 
  503.  
  504.  
  505. IS THAT REALLY USEFUL?
  506. -----------------------------------------------------------------
  507. It seems sort of silly to read input data from within the 
  508. computer but it does have a real purpose.  It is possible to read 
  509. data from an input device using any of the standard functions and 
  510. then do a format conversion in memory.  You could read in a line 
  511. of data, look at a few significant characters, then use these 
  512. formatted input routines to reduce the line of data to internal 
  513. representation.  That would sure beat writing your own data 
  514. formatting routines.
  515.  
  516.  
  517.  
  518.  
  519.  
  520.  
  521.                                                          Page 9-9
  522.  
  523.                                 Chapter 9 - Standard Input/Output
  524.  
  525. STANDARD ERROR OUTPUT
  526. -----------------------------------------------------------------
  527. Sometimes it is desirable to redirect the       =================
  528. output from the standard output device to a         SPECIAL.C
  529. file.  However, you may still want the error    =================
  530. messages to go to the standard output device, 
  531. in our case the monitor.  This next function allows you to do 
  532. that.  Load and display SPECIAL.C for an example of this new 
  533. function.  The program consists of a loop with two messages 
  534. output, one to the standard output device and the other to the 
  535. standard error device.  The message to the standard error device 
  536. is output with the function fprintf() and includes the device 
  537. name stderr as the first argument.  Other than those two small 
  538. changes, it is the same as our standard printf() function.  (You 
  539. will see more of the fprintf() function in the next chapter, but 
  540. its operation fit in better as a part of this chapter.)  Ignore 
  541. the line with the exit for the moment, we will return to it.
  542.  
  543. Compile and run this program, and you will find 12 lines of 
  544. output on the monitor.  To see the difference, run the program 
  545. again with redirected output to a file named STUFF by entering 
  546. the following line at the DOS prompt;
  547.  
  548.     C> special >stuff
  549.  
  550. This time you will only get the 6 lines output to the standard 
  551. error device, and if you look in your directory, you will find 
  552. that the file named STUFF contains the other 6 lines, those to 
  553. the standard output device.  You can use I/O redirection with any 
  554. of the programs we have run so far, and as you may guess, you can 
  555. also read from a file using I/O redirection but we will study a 
  556. better way to read from a file in the next chapter.  More 
  557. information about I/O redirection can be found in your DOS 
  558. manual.  
  559.  
  560.  
  561. WHAT ABOUT THE exit(4) STATEMENT?
  562. -----------------------------------------------------------------
  563. Now to keep our promise about the exit(4) statement. Redisplay 
  564. the file named SPECIAL.C on your monitor.  The last statement 
  565. exits the program and returns the value of 4 to DOS.  Any number 
  566. from 0 to 19 can be used in the parentheses for DOS 
  567. communication.  If you are operating in a BATCH file, this number 
  568. can be tested with the ERRORLEVEL command.
  569.  
  570. Most compilers that operate in several passes return a 1 with 
  571. this mechanism to indicate that a fatal error has been detected 
  572. and it would be a waste of time to go on to another pass 
  573. resulting in even more errors.
  574.  
  575. It is therefore wise to use a batch file for compiling programs 
  576. and testing the returned value for errors.  A check of the 
  577. documentation for my computer, resulted in a minimal and 
  578.  
  579.                                                         Page 9-10
  580.  
  581.                                 Chapter 9 - Standard Input/Output
  582.  
  583. confusing documentation of the ERRORLEVEL command, so a brief 
  584. description of it is given in this file in case your 
  585. documentation does not include enough information to allow you to 
  586. use it.
  587.  
  588. One additional feature must be mentioned here.  Since we wish to 
  589. return an int value to the operating system, we must define the 
  590. main program entry point as returning an int rather than a void 
  591. as we have used in most of the example programs to this point.  
  592. Refer to line 5 for an example of this extension.
  593.  
  594.  
  595. PROGRAMMING EXERCISES
  596. -----------------------------------------------------------------
  597. 1.  Write a program to read in a character using a loop, and 
  598.     display the character in its normal char form.  Also display 
  599.     it as a decimal number. Check for a dollar sign to use as the 
  600.     stop character.  Use the _getch() form of input so it will 
  601.     print immediately.  Hit some of the special keys, such as 
  602.     function keys, when you run the program for some surprises. 
  603.     You will get two inputs from the special keys, the first 
  604.     being a zero which is the indication to the system that a 
  605.     special key was hit.
  606.  
  607. 2.  Add a character string to SINGLEIO.C and store the input 
  608.     characters in the string.  When the X is detected, add a 
  609.     terminating null to the string and print out the string 
  610.     with a printf() function call.
  611.  
  612.  
  613.  
  614.  
  615.  
  616.  
  617.  
  618.  
  619.  
  620.  
  621.  
  622.  
  623.  
  624.  
  625.  
  626.  
  627.  
  628.  
  629.  
  630.  
  631.  
  632.  
  633.  
  634.  
  635.  
  636.  
  637.                                                         Page 9-11
  638.